///@创建者：磁心
///@创建日期：2020-06-23
///@文件描述:[List] 方法属性测试，并分类
///分类：
///1.list()对象方法
/// 2.LIST添加元素
/// 3.LIST获取元素
/// 4.LIST循环
/// 5.LIST内部元素判断
/// 6.其他
/// 7.LIST更新元素
/// 8.LIST类型转换
/// 9.其他作者不知道干嘛用的
///使用方法：运行命令：flutter test .\test\dart\List.dart
import 'package:flutter_test/flutter_test.dart';

void main() {
  test('测试list', () {


    /***
     *
     *分类：list()对象方法
     */

    ///new List()越界不会报错
//    var newList = new List(3); //越界会报错，不限定类型，可添加任意类型的数据,返回一个长度为3的List数组,限定了长度为3
//    print(newList);//[null, null, null]
//    newList.add('我又添加一个元素，看看会不会报错');
//    newList.remove(null);//也会报错
//    newList[0]='1';//赋值不会报错
//    print(newList);//报错：Unsupported operation: Cannot add to a fixed-length list
//    var emptyList=new List();
//    print('emptyList:${emptyList}');//emptyList:[]

    ///List.filled(length,element)，用element填充length的长度，长度固定，不能添加或减少长度啊,否则会报错，只能赋值
//    var filled=List.filled(3, '你好啊');
//  filled.add('value');
//  filled.remove('你好啊');
//    filled[1]='我是赋值操作';
//    print("filled:$filled");//filled:[你好啊, 你好啊, 你好啊]

    ///List.of()，初始化LIST,并能够添加或减少元素，长度不固定
//    var of=List.of(['of']);
//    of.add('我来添加一个元素');
//    print('of:${of}');//of:[of, 我来添加一个元素]
//    of.remove('aaa');
//    of.remove('of');
//    print('of:${of}');//of:[我来添加一个元素]
//    of[1]='我是赋值操作';//如果index是0，赋值index=1,会报错
//    print('of:${of}');
//    var lst=[
//      1,3,5,'of'
//    ];
//    lst[4]='赋值';
//    print(lst);//如果index是4，赋值index=5,会报错,看来只能用add方法添加元素了

    ///List.from()
//    try{
//      var from=List.from(['elements'],growable:false);//如果growable为false,代表不可成长的,冻结的List,如果再添加一个元素,则报错
////      from.add('我添加一个元素');
////      from.clear();
////      from[0]=1;//赋值不会报错哦
//
////      print("from:${from}");//from:[elements]
//    }catch(e){
//      print(e);//报错为:Unsupported operation: Cannot add to a fixed-length list
//    }

    ///List.unmodifiable()//冻结List，赋值操作也会被报错处理
//    try{
//      var unmodifiable=List.unmodifiable(['elements1','elements2']);
////      unmodifiable[0]='我要改变这片天';
////      unmodifiable.clear();
//      print(unmodifiable);
//    }catch(e){
//      print(e);//报错：Unsupported operation: Cannot modify an unmodifiable list
//
//    }

      ///List.generate()List生成器
//      var generate = List.generate(5, (index) => index.isEven ? index : 0);
//    print(generate);//[0, 0, 2, 0, 4]
    //      generate.add('添加元素操作');//报错，里面的类型也固定
//    var lst=['2','3'];
//    lst.add(3);//报错，里面的类型也固定

      ///List.castFrom 不知道干嘛的
//      var castFrom = List.castFrom([1, 2, 3, 4]); //不知道干嘛的
//    print(castFrom);//[1, 2, 3, 4]
//      castFrom.add(5);
//      castFrom[1]=6;
//      castFrom.remove(1);

    ///List.empty
//      var empty=List.empty();//长度固定了，不能更改
//      print('empty:${empty}');//empty:[]
//      print(empty.runtimeType);//List<dynamic>
//      if([] is List){
//        print('is');
//      }
//
//      empty.add(1);
//      print('empty:${empty}');//报错


    ///List.copyRange
//    List target=[1,2,3,4,5];
//    List source=['a','b','c','d'];
//    List.copyRange(target, 1,source ,2);
//    print("coypRange----target:${target},source:${source}");//coypRange----target:[1, c, d, 4, 5],source:[a, b, c, d]

    ///List.writeIterable
//    List target=[1,2,3,4,5];
//    List source=['a','b','c','d'];
//    List.writeIterable(target, 1, source);
//    print("writeIterable----target:${target},source:${source}");//writeIterable----target:[1, a, b, c, d],source:[a, b, c, d]


    List lst = [
      'String',
      123,
      245,
      123,
      true,
      123,
      null,
      {'age': 12}
    ];

    /***
     * 分类：LIST添加元素
     *
     *
     *
     */

//    ///add()在List末尾添加一个元素
//    lst.add('我是末尾添加的元素');//[String, 123, 245, 123, true, 123, null, {age: 12}, 我是末尾添加的元素]
//    lst.add('我是末尾添加的元素');//[String, 123, 245, 123, true, 123, null, {age: 12}, 我是末尾添加的元素, 我是末尾添加的元素]

    ///void lst.insert(index,element)在某一个位置上插入某个元素
//    lst.insert(3, '我是插入的第三个元素');
//    print(lst);//[String, 123, 245, 我是插入的第三个元素, 123, true, 123, null, {age: 12}]


    ///void lst.addAll()添加一个List类型并合并成一维数组
//    lst.addAll([1245,6334,'我也好',false,true,['哈啊']]);
//    print(lst);//[String, 123, 245, 123, true, 123, null, {age: 12}, 1245, 6334, 我也好, false, true, [哈啊]]


    /***
     *
     * 分类：LIST删除元素
     *
     *
     */


    ///void lst.remove()移除某个元素
    lst.remove('你好');//lst返回：[String, 123, 245, 123, true, 123, null, {age: 12}]


    ///removeLast()移除最后一个元素
//    lst.removeLast();//[String, 123, 245, 123, true, 123, null]
//    lst.removeLast();//[String, 123, 245, 123, true, 123]


    /// clear() 清空List，length为0
//    lst.clear();//[]

    ///lst.removeAt(index)移除某个index的元素
//    var removeAt=lst.removeAt(1);//
//    print(removeAt);//123
//    print(lst);//lst不变：[String, 245, 123, true, 123, null, {age: 12}]


    ///lst.removeRange(index,end)移除开始到结束的范围
//    lst.removeRange(1, 4);
//    print('lst:${lst}');//lst:[String, true, 123, null, {age: 12}]

    ///lst.removeLast()移除最后一个元素
//    var removeLast=lst.removeLast();
//    print('removeLast:${removeLast}');//removeLast:{age: 12}
//    print('lst:${lst}');//lst也会变化啊：[String, true, 123, null]

    ///lst.removeWhere((e){})//移除否些某个条件的元素
//    lst.removeWhere((element) => element==true);
//    print('lst:${lst}');//lst:[String, 123, 245, 123, 123, null, {age: 12}]










    /****
     *
     *
     * 分类：LIST获取元素
     *
     *
     *
     *
     */

    ///    lst.getRange 获取List范围,需要用toList()转换
//    print(lst.getRange(0, 3));//(String, 123, 245)

//    lst.sublist(index,[end])从某个开始位置开始剪切
//    print(lst.sublist(3));//[123, true, 123, null, {age: 12}]

//    print(lst.sublist(2,3));//[245]

    ///lst.elementAt(index)通过index来获取某个元素
//    var elementAt=lst.elementAt(3);//
//    print(elementAt);///123

    ///lst.firstWhere((e){},orElse)返回第一个符合条件的元素,后面是获取不到的处理函数
    ///orElse
//    String orElse(){
//      return 'orElse';
//    }
//    var firstWhere1=lst.firstWhere((element) => element.toString().length>10,orElse:orElse);//
//    print('firstWhere1:${firstWhere1}');//firstWhere1:orElse
//    var firstWhere2=lst.firstWhere((element) => element.toString().length>6,orElse:orElse);//
//    print('firstWhere2:${firstWhere2}');//firstWhere2:{age: 12}






    /***
     * 分类：LIST更新元素
     *
     *
     *
     *
     *
     */


    ///lst.setAll(index,iterable)进行某个范围的元素替换
//    lst.setAll(2,['setAll1','setAll2','setAll3']);
//    print('lst:${lst}');//lst:[String, 123, setAll1, setAll2, setAll3, 123, null, {age: 12}]



    ///void lst.fillRange()填充元素，注意不能超过原来的List长度
//    lst.fillRange(0, 2,'我是填充值');//
//    print(lst);//[我是填充值, 我是填充值, 245, 123, true, 123, null, {age: 12}]

    ///lst.replaceRange()替换元素，并且不限制List长度
//    lst.replaceRange(0, 2, [1,2,3,4]);
//    print('lst:${lst}');//lst:[1, 2, 3, 4, 245, 123, true, 123, null, {age: 12}]


    ///void lst.setRange(start,end,iterable,[skipCount])设置某个List范围内的元素,最后一个参数代表是从哪开始
//    lst.setRange(0, 3, [0,3,2,3,4,5],3);//从第三个开始
//    print(lst);//[3, 4, 5, 123, true, 123, null, {age: 12}]



    /***
     *
     *
     * 分类：LIST循环
     *
     *
     */



//for(var item in lst){
//  print('element:${item}');
////  element:String
////  element:123
////  element:245
////  element:123
////  element:true
////  element:123
////  element:null
////  element:{age: 12}
//}

//  for(int i=0;i<lst.length;i++){
//    print('element:${lst[i]}');
////    element:String
////    element:123
////    element:245
////    element:123
////    element:true
////    element:123
////    element:null
////    element:{age: 12}
//
//  }


//    lst.forEach((e){})//List循环
//    lst.forEach((element) {
//      print('element:$element');
////      element:String
////      element:123
////      element:245
////      element:123
////      element:true
////      element:123
////      element:null
////      element:{age: 12}
//
//    });

    ///lst.map() 映射遍历，返回的并不是List类型的数据，必须加个toList()方法
//    var newList=lst.map((e){
//      return e.toString()*2;
//    });
//     print(newList);//(StringString, 123123, 245245, 123123, ..., nullnull, {age: 12}{age: 12})
    //    print(newList.runtimeType);//类型为：MappedListIterable<dynamic, String>

    /***
     *
     * 分类：LIST转换类型
     *
     *
     *
     */

    ///lst.asMap()转Map类型
//    var lstmap=lst.asMap();
//    print(lstmap);//{0: String, 1: 123, 2: 245, 3: 123, 4: true, 5: 123, 6: null, 7: {age: 12}}

    /// lst.toString() List转字符串类型
//    print('lst.toString():${lst.toString()}');//lst.toString():[String, 123, 245, 123, true, 123, null, {age: 12}]

    ///lst.toList()转List类型
//    print('lst.toList():${lst.toList()}');//lst.toList():[String, 123, 245, 123, true, 123, null, {age: 12}]
//    print('lst.toList():${lst.toList().runtimeType}');//lst.toList():List<dynamic>


    ///lst.toSet 转换为set类型这个方法可以把元素里重复的值去重，挺有趣的
//    var toSet=lst.toSet();
//    print(toSet);//{String, 123, 245, true, null, {age: 12}}


    /****
     * 分类：LIST属性
     *
     *
     *
     *
     */

    ///lst.runtimeType 返回类型
//    print("lst.runtimeType:${lst.runtimeType}");//lst.runtimeType:List<dynamic>

    //lst.isEmpty是否为空
//    print(lst.isEmpty);//false

    //lst.isNotEmpty 是否不为空
//    print(lst.isNotEmpty);//true

    ///lst.length 获取长度，也可以设置长度哦
    ////获取长度
//    print('List长度：${lst.length}');//List长度：8
////    设置长度
//    lst.length=10;
//    print(lst);//[String, 123, 245, 123, true, 123, null, {age: 12}, null, null]

    ///lst.first获取第一个元素
//    print("lst.first:${lst.first}");//lst.first:String



    ///lst.iterator返回一个ListIterator<dynamic>的类型,是个List迭代类型
//    var iterator=lst.iterator;
//    iterator.moveNext();
//    iterator.moveNext();
//    iterator.moveNext();
//    print(iterator.current);//245

///lst.last获取最后一个元素,如果没有元素，则会报错
//    lst.clear();
//    var last=lst.last;
//    print(last);//Bad state: No element


    ///lst.reversed元素反向，有意思啊
//    print(lst.reversed);//({age: 12}, null, 123, true, 123, 245, 123, String)
//    print(lst);//lst不变：[String, 123, 245, 123, true, 123, null, {age: 12}]

    ///lst.hashCode得到一个hash码，不知道有什么用,
//    print(lst.hashCode);//756200036

    ///lst.single 是否是单一元素的List,如果是单一元素，则返回这个元素，如果不是单一元素的[List],则报错，不知道干嘛的
//        var singleList=['a'];
//        print('singleList.single:${singleList.single}');//singleList.single:a
//        try{
//          var single=lst.single;
//        }catch(e){
//          print(e);//Bad state: Too many elements
//
//        }



    /***
     *
     * 分类：LIST内部元素判断
     *
     *
     *
     *
     */

    ///lst.indexOf(element)获取某个元素的index,获取不到时，返回-1
//    var index=lst.indexOf('你好');
//    print(index);//-1


    ///lst.indexWhere((e){},index)返回符合条件元素的第一个index值
//    var indexWhere=lst.indexWhere((element) => element.toString().length>6);//
//    print(indexWhere);//7


    ///lst.lastIndexOf(element,[start])获取某个元素最后一次出现的index位置,index都是从0开始的，常识
//    var lastIndexOf= lst.lastIndexOf(123);
//    print(lastIndexOf);//5

    ///lst.lastIndexWhere((e){},[start])通过条件判断获取符合条件的最后一次出现的index位置
//    var lastIndexWhere=lst.lastIndexWhere((element) => element.toString().length<4);
//    print('lastIndexWhere:${lastIndexWhere}');//lastIndexWhere:5


    ///lst.contains()     是否包含某个元素
//    print(lst.contains('你好'));//false

    ///lst.any((){}) //内部任何一个元素符合条件，返回true
//    var any=lst.any((element) => element.toString().length>10);//
//    print(any);//false


    ///lst.every((){})每个都符合才行呐
//    var lstEvery=lst.every((element) => element.toString().length==3);//
//    print('lstEvery：${lstEvery}');//lstEvery：false

    ///lst.retainWhere((e){})返回一个新的符合条件元素的List,重要***
//    lst.retainWhere((element) => element.toString().length>5);
//    print(lst);//[String, {age: 12}]
//    lst.retainWhere((element) => element.toString().length>20);
//    print(lst);//[]

    ///lst.where返回所有符合条件的元素
//    var where=lst.where((element) => element.toString().length>5);
//    print(where);//(String, {age: 12})

    /***
     *
     * 分类：其他
     *
     *
     *
     */





    ///lst.expand()//成对扩大
//    var expand = lst.expand((pair) => [pair,pair]).toList();
//    print(expand);//[String, String, 123, 123, 245, 245, 123, 123, true, true, 123, 123, null, null, {age: 12}, {age: 12}]



    ///lst.join(string)用某个字符连接，返回字符串
//    var join=lst.join(',');
//    print(join);//String,123,245,123,true,123,null,{age: 12}







    ///lst.sort((e1,e2){})排序
//    var intLst=[
//      2,3,6,1,0,4,19
//    ];
//    lst.sort((e1,e2){
//      return e2.toString().hashCode-e1.toString().hashCode;//e1-e2减号是升序，e2-e1是降序
//    });
//    print(lst);//[null, {age: 12}, true, 245, 123, 123, 123, String]

    //lst.shuffle()随机数组
//    lst.shuffle();
//    print("lst:${lst}");//lst:[123, 123, String, {age: 12}, 245, true, null, 123]


    /****
     * 分类：LIST不知道有啥用的
     *
     *
     *
     *
     *
     */



    ///lst.cast() cast是投，抛射的意思。 将List的泛型提升到其父祖类
//    List<Object> lstcast=lst.cast();
//    print(lstcast);//[String, 123, 245, 123, true, 123, null, {age: 12}]
//   var newlist=new List();
//   newlist.add('12');
//   newlist.add('33');
//   newlist.add(5);
//   print(newlist);//[12, 33, 5]



    ///lst.take(count)截取count的长度，获取一个SubListIterable类型的数据，不知道干嘛的
    ///从0开始取count个元素，并返回结果 takeWhile((e)=>(bool)) 从0开始取，直至第一个不符合函数的元素，将其前面的元素都返回
//    var take=lst.take(5);//
//    print(take);//(String, 123, 245, 123, true)
//    print(take.runtimeType);//SubListIterable<dynamic>



    ///lst.fold()和第一个元素，内部元素进行重复操作，返回一个总值,好像挺牛逼 的样子
//    var fold=  lst.fold(5, (prev, element) => prev.toString() + element.toString());
//    print(fold);//5String123245123true123null{age: 12}



    ///lst.reduce:::reduce是减少降低的意思，(某种操作)) 用指定的方法对元素做连续操作，将结果返回
//    var reduce=lst.reduce((value, element) => value.toString()+element.toString());
//    print('reduce:${reduce}');//String123245123true123null{age: 12}




    ///lst.skip(count)从开头忽略两个元素,返回 [SubListIterable<dynamic>] 类型
    ///越过count个元素后，开始返回list的Iterable skipWhile((e)=>(bool)) 根据参数函数，找到第一个不符合条件的元素，然后将其及其后的元素返回
//    Iterable<dynamic> skip=lst.skip(2);//越过2个元素后，开始返回list的Iterable
//    print(skip);//(245, 123, true, 123, null, {age: 12})
//    print(skip.runtimeType);//SubListIterable<dynamic>
//    print(lst);//[String, 123, 245, 123, true, 123, null, {age: 12}]

    ///lst.skipWhile 不知道干嘛的
//var skipWhile=lst.skipWhile((value) => value==324);
//    print(skipWhile);//(String, 123, 245, 123, true, 123, null, {age: 12})

 ///lst.takeWhile从第一个元素开始，逐个判断是否符合参数函数，直至第一个不符合的元素，将其前面元素都返回
//    Iterable<dynamic> takeWhile=lst.takeWhile((value) => value.toString().length>5);
//    print(takeWhile);//(String)

    ///lst.singleWhere()判断第一个元素是否是List的第一个元素，不是的话就报错，不知道干嘛的
//    var singleWhere1=lst.singleWhere((element) => element=='String');//
//    print(singleWhere1);//String
//    try{
//      var singleWhere=lst.singleWhere((element) => element==123);//
//      print(singleWhere);
//    }catch(e){
//      print(e);//Bad state: Too many elements
//    }

    ///lst.followedBy()在List的尾部添加List，返回EfficientLengthFollowedByIterable类型的数据
//    var followedBy=lst.followedBy([1,23,5]);
//    print(followedBy);//(String, 123, 245, 123, true, 123, null, {age: 12}, 1, 23, 5)
//    print(followedBy.runtimeType);//EfficientLengthFollowedByIterable<dynamic>

    ///lst.whereType()返回WhereTypeIterable类型,筛选类型用的
//    Iterable<int> whereType1=lst.whereType();
//    print(whereType1);//(123, 245, 123, 123)
//    print(whereType1.runtimeType);//WhereTypeIterable<dynamic>
//    Iterable<String> whereType2=lst.whereType();
//    print(whereType2);//(String)



////////    var noSuchMethod=lst.noSuchMethod(///不知道怎么用
////////        Invocation.method(Symbol a);
////////    );
//    print(noSuchMethod);



















  });
}
